home *** CD-ROM | disk | FTP | other *** search
/ Visual Cafe 3 / Visual Cafe 3.ISO / Vcafe / JFC.bin / JLabel.java < prev    next >
Text File  |  1998-06-30  |  25KB  |  777 lines
  1. /*
  2.  * @(#)JLabel.java    1.65 98/03/16
  3.  * 
  4.  * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
  5.  * 
  6.  * This software is the confidential and proprietary information of Sun
  7.  * Microsystems, Inc. ("Confidential Information").  You shall not
  8.  * disclose such Confidential Information and shall use it only in
  9.  * accordance with the terms of the license agreement you entered into
  10.  * with Sun.
  11.  * 
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  13.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  14.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  15.  * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
  16.  * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
  17.  * THIS SOFTWARE OR ITS DERIVATIVES.
  18.  * 
  19.  */
  20.  
  21. package com.sun.java.swing;
  22.  
  23. import java.awt.Component;
  24. import java.awt.Font;
  25. import java.awt.Image;
  26. import com.sun.java.accessibility.*;
  27. import com.sun.java.swing.plaf.*;
  28.  
  29.  
  30. /**
  31.  * A display area for a short text string or an image,
  32.  * or both.
  33.  * A label does not react to input events.
  34.  * As a result, it cannot get the keyboard focus.
  35.  * A label can, however, display a keyboard alternative
  36.  * as a convenience for a nearby component
  37.  * that has a keyboard alternative but can't display it.
  38.  * <p>
  39.  * A <code>JLabel</code> object can display
  40.  * either text, an image, or both.
  41.  * You can specify where in the label's display area
  42.  * the label's contents are aligned
  43.  * by setting the vertical and horizontal alignment.
  44.  * By default, labels are vertically centered 
  45.  * in their display area.
  46.  * Text-only labels are left-aligned, by default;
  47.  * image-only labels are horizontally centered, by default.
  48.  * <p>
  49.  * You can also specify the position of the text
  50.  * relative to the image.
  51.  * By default, text is to the right of the image,
  52.  * with the text and image vertically aligned.
  53.  * <p>
  54.  * Finally, you can use the <code>setIconTextGap</code> method
  55.  * to specify how many pixels
  56.  * should appear between the text and the image.
  57.  * The default is 4 pixels.
  58.  * <p>
  59.  * See <a href="http://java.sun.com/docs/books/tutorial/ui/swing/label.html">How to Use Labels</a>
  60.  * in <a href="http://java.sun.com/Series/Tutorial/index.html"><em>The Java Tutorial</em></a>
  61.  * for further documentation.
  62.  * <p>
  63.  * Warning: serialized objects of this class will not be compatible with
  64.  * future swing releases.  The current serialization support is appropriate 
  65.  * for short term storage or RMI between Swing1.0 applications.  It will
  66.  * not be possible to load serialized Swing1.0 objects with future releases
  67.  * of Swing.  The JDK1.2 release of Swing will be the compatibility
  68.  * baseline for the serialized form of Swing objects.
  69.  *
  70.  * @beaninfo
  71.  *   attribute: isContainer false
  72.  * description: A component that displays a short string and an icon.
  73.  * 
  74.  * @version 1.65 03/16/98
  75.  * @author Hans Muller
  76.  */
  77. public class JLabel extends JComponent implements SwingConstants, Accessible
  78. {
  79.     private int mnemonic = '\0';
  80.  
  81.     private String text = "";         // "" rather than null, for BeanBox
  82.     private Icon defaultIcon = null;
  83.     private Icon disabledIcon = null;
  84.             
  85.     private int verticalAlignment = CENTER;
  86.     private int horizontalAlignment = LEFT;
  87.     private int verticalTextPosition = CENTER;
  88.     private int horizontalTextPosition = RIGHT;
  89.     private int iconTextGap = 4;
  90.             
  91.  
  92.     /**
  93.      * Creates a <code>JLabel</code> instance with the specified
  94.      * text, image, and horizontal alignment.
  95.      * The label is centered vertically in its display area.
  96.      * The text is to the right of the image.
  97.      *
  98.      * @param text  The text to be displayed by the label.
  99.      * @param icon  The image to be displayed by the label.
  100.      * @param horizontalAlignment  One of the following constants
  101.      *           defined in <code>SwingConstants</code>:
  102.      *           <code>LEFT</code>,
  103.      *           <code>CENTER</code>, or
  104.      *           <code>RIGHT</code>.
  105.      */
  106.     public JLabel(String text, Icon icon, int horizontalAlignment) {
  107.         setText(text);
  108.         setIcon(icon);
  109.         setHorizontalAlignment(horizontalAlignment);
  110.         updateUI();
  111.         setAlignmentX(LEFT_ALIGNMENT);
  112.     }
  113.             
  114.     /**
  115.      * Creates a <code>JLabel</code> instance with the specified
  116.      * text and horizontal alignment.
  117.      * The label is centered vertically in its display area.
  118.      *
  119.      * @param text  The text to be displayed by the label.
  120.      * @param horizontalAlignment  One of the following constants
  121.      *           defined in <code>SwingConstants</code>:
  122.      *           <code>LEFT</code>,
  123.      *           <code>CENTER</code>, or
  124.      *           <code>RIGHT</code>.
  125.      */
  126.     public JLabel(String text, int horizontalAlignment) {
  127.         this(text, null, horizontalAlignment);
  128.     }
  129.  
  130.     /**
  131.      * Creates a <code>JLabel</code> instance with the specified text.
  132.      * The label is aligned against the left side of its display area,
  133.      * and centered vertically.
  134.      *
  135.      * @param text  The text to be displayed by the label.
  136.      */
  137.     public JLabel(String text) {
  138.         this(text, null, LEFT);
  139.     }
  140.  
  141.     /**
  142.      * Creates a <code>JLabel</code> instance with the specified
  143.      * image and horizontal alignment.
  144.      * The label is centered vertically in its display area.
  145.      *
  146.      * @param icon  The image to be displayed by the label.
  147.      * @param horizontalAlignment  One of the following constants
  148.      *           defined in <code>SwingConstants</code>:
  149.      *           <code>LEFT</code>,
  150.      *           <code>CENTER</code>, or
  151.      *           <code>RIGHT</code>.
  152.      */
  153.     public JLabel(Icon image, int horizontalAlignment) {
  154.         this(null, image, horizontalAlignment);
  155.     }
  156.  
  157.     /**
  158.      * Creates a <code>JLabel</code> instance with the specified image.
  159.      * The label is centered vertically and horizontally
  160.      * in its display area.
  161.      *
  162.      * @param icon  The image to be displayed by the label.
  163.      */
  164.     public JLabel(Icon image) {
  165.         this(null, image, CENTER);
  166.     }
  167.  
  168.     /**
  169.      * Creates a <code>JLabel</code> instance with 
  170.      * no image and with an empty string for the title.
  171.      * The label is centered vertically 
  172.      * in its display area.
  173.      * The label's contents, once set, will be displayed at the left 
  174.      * of the label's display area.
  175.      */
  176.     public JLabel() {
  177.         this("", null, LEFT);
  178.     }
  179.  
  180.  
  181.     /**
  182.      * Returns the L&F object that renders this component.
  183.      *
  184.      * @return LabelUI object
  185.      */
  186.     public LabelUI getUI() {
  187.         return (LabelUI)ui;
  188.     }
  189.  
  190.  
  191.     /**
  192.      * Sets the L&F object that renders this component.
  193.      *
  194.      * @param ui  the LabelUI L&F object
  195.      * @see UIDefaults#getUI
  196.      * @beaninfo
  197.      *      expert: true
  198.      *  description: The L&F object that renders this component.
  199.      */
  200.     public void setUI(LabelUI ui) {
  201.         super.setUI(ui);
  202.     }
  203.  
  204.  
  205.     /**
  206.      * Notification from the UIFactory that the L&F
  207.      * has changed. 
  208.      *
  209.      * @see JComponent#updateUI
  210.      */
  211.     public void updateUI() {
  212.         setUI((LabelUI)UIManager.getUI(this));
  213.         invalidate();
  214.     }
  215.  
  216.  
  217.     /**
  218.      * Returns a string that specifies the name of the l&f class
  219.      * that renders this component.
  220.      *
  221.      * @return String "LabelUI"
  222.      *
  223.      * @see JComponent#getUIClassID
  224.      * @see UIDefaults#getUI
  225.      */
  226.     public String getUIClassID() {
  227.         return "LabelUI";
  228.     }
  229.  
  230.  
  231.     /** 
  232.      * Returns the text string that the label displays.
  233.      *
  234.      * @return a String
  235.      * @see #setText
  236.      */
  237.     public String getText() {
  238.         return text;
  239.     }
  240.  
  241.  
  242.     /**
  243.      * Defines the single line of text this component will display.  If
  244.      * the value of text is null or empty string, nothing is displayed.
  245.      * <p>
  246.      * The default value of this property is null.
  247.      * <p>
  248.      * This is a JavaBeans bound property.  
  249.      * 
  250.      * @see #setVerticalTextPosition
  251.      * @see #setHorizontalTextPosition
  252.      * @see #setIcon
  253.      * @beaninfo
  254.      *        bound: true
  255.      *  description: Defines the single line of text this component will display.
  256.      */
  257.     public void setText(String text) {
  258.  
  259.         String oldAccessibleName = null;
  260.         if (accessibleContext != null) {
  261.             oldAccessibleName = accessibleContext.getAccessibleName();
  262.         }
  263.  
  264.         String oldValue = this.text;
  265.         this.text = text;
  266.         firePropertyChange("text", oldValue, text);
  267.  
  268.         if ((accessibleContext != null) 
  269.             && (accessibleContext.getAccessibleName() != oldAccessibleName)) {
  270.                 accessibleContext.firePropertyChange(
  271.                         AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY, 
  272.                         oldAccessibleName,
  273.                         accessibleContext.getAccessibleName());
  274.         }
  275.  
  276.         repaint();
  277.     }
  278.  
  279.     
  280.     /**
  281.      * Returns the graphic image (glyph, icon) that the label displays.
  282.      *
  283.      * @return an Icon
  284.      * @see #setIcon
  285.      */
  286.     public Icon getIcon() {
  287.         return defaultIcon;
  288.     }
  289.  
  290.     /**
  291.      * Defines the icon this component will display.  If
  292.      * the value of icon is null, nothing is displayed.
  293.      * <p>
  294.      * The default value of this property is null.
  295.      * <p>
  296.      * This is a JavaBeans bound property.  
  297.      * 
  298.      * @see #setVerticalTextPosition
  299.      * @see #setHorizontalTextPosition
  300.      * @see #getIcon
  301.      * @beaninfo
  302.      *        bound: true
  303.      *  description: The icon this component will display.
  304.      */
  305.     public void setIcon(Icon icon) {
  306.         Icon oldValue = icon;
  307.         defaultIcon = icon;
  308.         firePropertyChange("icon", oldValue, defaultIcon);
  309.  
  310.         if ((accessibleContext != null) && (oldValue != defaultIcon)) {
  311.                 accessibleContext.firePropertyChange(
  312.                         AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY, 
  313.                         oldValue, defaultIcon);
  314.         }
  315.  
  316.         repaint(10);
  317.     }
  318.  
  319.  
  320.     /**
  321.      * Returns the value of the disabledIcon property if it's been set,
  322.      * If it hasn't been set and the value of the icon property is
  323.      * an ImageIcon, we compute a "grayed out" version of the icon and
  324.      * update the disabledIcon property with that.
  325.      * 
  326.      * @return The value of the disabledIcon property.
  327.      * @see #setDisabledIcon
  328.      * @see ImageIcon
  329.      */
  330.     public Icon getDisabledIcon() 
  331.     {
  332.         if((disabledIcon == null) && 
  333.            (defaultIcon != null) && 
  334.            (defaultIcon instanceof ImageIcon)) {
  335.             Image grayImage = GrayFilter.createDisabledImage(((ImageIcon)defaultIcon).getImage());
  336.             disabledIcon = new ImageIcon(grayImage);
  337.             firePropertyChange("disabledIcon", null, disabledIcon);
  338.         }
  339.         return disabledIcon;
  340.     }
  341.  
  342.  
  343.     /**
  344.      * Set the icon to be displayed if this JLabel is "disabled", i.e.
  345.      * JLabel.setEnabled(false).
  346.      * <p>
  347.      * The default value of this property is null.
  348.      * 
  349.      * @param disabledIcon the Icon to display when the component is disabled
  350.      * @see #getDisabledIcon
  351.      * @see #setEnabled
  352.      * @beaninfo
  353.      *        bound: true
  354.      *  description: The value of the disabledIcon property if it 
  355.      *               has been set.
  356.      */
  357.     public void setDisabledIcon(Icon disabledIcon) {
  358.         Icon oldValue = this.disabledIcon;
  359.         this.disabledIcon = disabledIcon;
  360.         firePropertyChange("disabledIcon", oldValue, disabledIcon);
  361.         repaint(10);
  362.     }
  363.  
  364.  
  365.     /**
  366.      * Specify a keycode that indicates a mnemonic key.
  367.      * This property is used when the label is part of a larger component.  
  368.      * If the labelFor property of the label is not null, the label will
  369.      * call the requestFocus method of the component specified by the
  370.      * labelFor property when the mnemonic is activated.
  371.      *
  372.      * @see #getLabelFor
  373.      * @see #setLabelFor
  374.      * @beaninfo
  375.      *        bound: true
  376.      *  description: The keycode that indicates a mnemonic key.
  377.      */
  378.     public void setDisplayedMnemonic(int key) {
  379.         int oldKey = mnemonic;
  380.         mnemonic = key;
  381.         firePropertyChange("displayedMnemonic", oldKey, mnemonic);
  382.         repaint();
  383.     }
  384.  
  385.     public void setDisplayedMnemonic(char aChar) {
  386.         int vk = (int) aChar;
  387.         if(vk >= 'a' && vk <='z')
  388.             vk -= ('a' - 'A');
  389.         setDisplayedMnemonic(vk);
  390.     }
  391.  
  392.     /**
  393.      * Return the keycode that indicates a mnemonic key.
  394.      * This property is used when the label is part of a larger component.
  395.      * If the labelFor property of the label is not null, the label will
  396.      * call the requestFocus method of the component specified by the
  397.      * labelFor property when the mnemonic is activated.
  398.      *
  399.      * @return int value for the mnemonic key
  400.      *
  401.      * @see #getLabelFor
  402.      * @see #setLabelFor
  403.      */
  404.     public int getDisplayedMnemonic() {
  405.         return mnemonic;
  406.     }
  407.  
  408.  
  409.     /**
  410.      * Verify that key is a legal value for the 
  411.      * horizontalAlignment or horizontalTextPosition properties.
  412.      *
  413.      * @param key the property value to check
  414.      * @param message the IllegalArgumentException detail message 
  415.      * @exception IllegalArgumentException if key isn't LEFT, CENTER, or RIGHT.
  416.      * @see #setHorizontalAlignment
  417.      * @see #setHorizontalTextPosition
  418.      */
  419.     protected int checkHorizontalKey(int key, String message) {
  420.         if ((key == LEFT) || (key == CENTER) || (key == RIGHT)) {
  421.             return key;
  422.         }
  423.         else {
  424.             throw new IllegalArgumentException(message);
  425.         }
  426.     }
  427.  
  428.  
  429.     /**
  430.      * Verify that key is a legal value for the 
  431.      * verticalAlignment or verticalTextPosition properties.
  432.      *
  433.      * @param key the property value to check
  434.      * @param message the IllegalArgumentException detail message 
  435.      * @exception IllegalArgumentException if key isn't TOP, CENTER, or BOTTOM.
  436.      * @see #setVerticalAlignment
  437.      * @see #setVerticalTextPosition
  438.      */
  439.     protected int checkVerticalKey(int key, String message) {
  440.         if ((key == TOP) || (key == CENTER) || (key == BOTTOM)) {
  441.             return key;
  442.         }
  443.         else {
  444.             throw new IllegalArgumentException(message);
  445.         }
  446.     }
  447.  
  448.  
  449.     /**
  450.      * Returns the amount of space between the text and the icon
  451.      * displayed in this label.
  452.      *
  453.      * @return an int equal to the number of pixels between the text
  454.      *         and the icon.
  455.      * @see #setIconTextGap
  456.      */
  457.     public int getIconTextGap() {
  458.         return iconTextGap;
  459.     }
  460.  
  461.  
  462.     /**
  463.      * If both the icon and text properties are set, this property
  464.      * defines the space between them.  
  465.      * <p>
  466.      * The default value of this property is 4 pixels.
  467.      * <p>
  468.      * This is a JavaBeans bound property.
  469.      * 
  470.      * @see #getIconTextGap
  471.      * @beaninfo
  472.      *        bound: true
  473.      *  description: If both the icon and text properties are set, this
  474.      *               property defines the space between them.
  475.      */
  476.     public void setIconTextGap(int iconTextGap) {
  477.         int oldValue = iconTextGap;
  478.         this.iconTextGap = iconTextGap;
  479.         firePropertyChange("iconTextGap", oldValue, iconTextGap);
  480.         invalidate();
  481.         repaint(10);
  482.     }
  483.  
  484.  
  485.  
  486.     /**
  487.      * Returns the alignment of the label's contents along the Y axis.
  488.      *
  489.      * @return   The value of the verticalAlignment property, one of the 
  490.      *           following constants defined in <code>SwingConstants</code>:
  491.      *           <code>TOP</code>,
  492.      *           <code>CENTER</code>, or
  493.      *           <code>BOTTOM</code>.
  494.      *
  495.      * @see SwingConstants
  496.      * @see #setVerticalAlignment
  497.      */
  498.     public int getVerticalAlignment() {
  499.         return verticalAlignment;
  500.     }
  501.  
  502.  
  503.     /**
  504.      * Sets the alignment of the label's contents along the Y axis.  
  505.      * <p>
  506.      * The default value of this property is CENTER.
  507.      * <p>
  508.      * This is a JavaBeans bound property.
  509.      * 
  510.      * @param alignment One of the following constants
  511.      *           defined in <code>SwingConstants</code>:
  512.      *           <code>TOP</code>,
  513.      *           <code>CENTER</code> (the default), or
  514.      *           <code>BOTTOM</code>.
  515.      *
  516.      * @see SwingConstants
  517.      * @see #getVerticalAlignment
  518.      * @beaninfo
  519.      *        bound: true
  520.      *  description: The alignment of the label's contents along the Y axis.  
  521.      */
  522.     public void setVerticalAlignment(int alignment) {
  523.         if (alignment == verticalAlignment) return;
  524.         int oldValue = verticalAlignment;
  525.         verticalAlignment = checkVerticalKey(alignment, "verticalAlignment");
  526.         firePropertyChange("verticalAlignment", oldValue, verticalAlignment);   
  527.         repaint(10);
  528.     }
  529.  
  530.  
  531.     /**
  532.      * Returns the alignment of the label's contents along the X axis.
  533.      *
  534.      * @return   The value of the horizontalAlignment property, one of the 
  535.      *           following constants defined in <code>SwingConstants</code>:
  536.      *           <code>LEFT</code>,
  537.      *           <code>CENTER</code>, or
  538.      *           <code>RIGHT</code>.
  539.      *
  540.      * @see #setHorizontalAlignment
  541.      * @see SwingConstants
  542.      */
  543.     public int getHorizontalAlignment() {
  544.         return horizontalAlignment;
  545.     }
  546.  
  547.     /**
  548.      * Sets the alignment of the label's contents along the X axis.
  549.      * <p>
  550.      * This is a JavaBeans bound property.
  551.      *
  552.      * @param alignment  One of the following constants
  553.      *           defined in <code>SwingConstants</code>:
  554.      *           <code>LEFT</code> (the default for text-only labels),
  555.      *           <code>CENTER</code> (the default for image-only labels), or
  556.      *           <code>RIGHT</code>.
  557.      *
  558.      * @see SwingConstants
  559.      * @see #getHorizontalAlignment
  560.      * @beaninfo
  561.      *        bound: true
  562.      *  description: The alignment of the label's content along
  563.      *               the X axis.
  564.      */
  565.     public void setHorizontalAlignment(int alignment) {
  566.         if (alignment == horizontalAlignment) return;
  567.         int oldValue = horizontalAlignment;
  568.         horizontalAlignment = checkHorizontalKey(alignment, "horizontalAlignment");
  569.         firePropertyChange("horizontalAlignment", oldValue, horizontalAlignment);
  570.         repaint(10);
  571.     }
  572.  
  573.  
  574.     /**
  575.      * Returns the vertical position of the label's text,
  576.      * relative to its image.
  577.      *
  578.      * @return   One of the following constants
  579.      *           defined in <code>SwingConstants</code>:
  580.      *           <code>TOP</code>,
  581.      *           <code>CENTER</code>, or
  582.      *           <code>BOTTOM</code>.
  583.      *
  584.      * @see #setVerticalTextPosition
  585.      * @see SwingConstants
  586.      */
  587.     public int getVerticalTextPosition() {
  588.         return verticalTextPosition;
  589.     }
  590.  
  591.     /**
  592.      * Sets the vertical position of the label's text,
  593.      * relative to its image.
  594.      * <p>
  595.      * The default value of this property is CENTER.
  596.      * <p>
  597.      * This is a JavaBeans bound property.
  598.      *
  599.      * @param textPosition  One of the following constants
  600.      *           defined in <code>SwingConstants</code>:
  601.      *           <code>TOP</code>,
  602.      *           <code>CENTER</code> (the default), or
  603.      *           <code>BOTTOM</code>.
  604.      *
  605.      * @see SwingConstants
  606.      * @see #getVerticalTextPosition
  607.      * @beaninfo
  608.      *        bound: true
  609.      *  description: The vertical position of the text
  610.      *               relative to it's image.
  611.      */
  612.     public void setVerticalTextPosition(int textPosition) {
  613.         if (textPosition == verticalTextPosition) return;
  614.         int oldValue = verticalTextPosition;
  615.         verticalTextPosition = checkVerticalKey(textPosition, "verticalTextPosition");
  616.         firePropertyChange("verticalTextPosition", oldValue, verticalTextPosition);
  617.         repaint(10);
  618.     }
  619.  
  620.  
  621.     /**
  622.      * Returns the horizontal position of the label's text,
  623.      * relative to its image.
  624.      *
  625.      * @return   One of the following constants
  626.      *           defined in <code>SwingConstants</code>:
  627.      *           <code>LEFT</code>,
  628.      *           <code>CENTER</code>, or
  629.      *           <code>RIGHT</code>.
  630.      *
  631.      * @see SwingConstants
  632.      */
  633.     public int getHorizontalTextPosition() {
  634.         return horizontalTextPosition;
  635.     }
  636.  
  637.     /**
  638.      * Sets the horizontal position of the label's text,
  639.      * relative to its image.
  640.      *
  641.      * @param x  One of the following constants
  642.      *           defined in <code>SwingConstants</code>:
  643.      *           <code>LEFT</code>,
  644.      *           <code>CENTER</code>, or
  645.      *           <code>RIGHT</code> (the default).
  646.      *
  647.      * @see SwingConstants
  648.      * @beaninfo
  649.      *       expert: true
  650.      *  description: The horizontal position of the label's text, 
  651.      *               relative to its image.
  652.      */
  653.     public void setHorizontalTextPosition(int x) {
  654.         if (x == horizontalTextPosition) return;
  655.         horizontalTextPosition = checkHorizontalKey(x, "horizontalTextPosition");
  656.         repaint(10);
  657.     }
  658.  
  659.  
  660.     /**
  661.      * Sets the font used to display the label's text.
  662.      *
  663.      * @param font  The font to use.
  664.      */
  665.     public void setFont(Font font) {
  666.         super.setFont(font);
  667.         repaint(10);
  668.     }
  669.  
  670.  
  671.     /**
  672.      * --- Accessibility Support ---
  673.      */
  674.  
  675.     protected Component labelFor = null;
  676.  
  677.     /** 
  678.      * Get the AccessibleContext of this object 
  679.      *
  680.      * @return the AccessibleContext of this object
  681.      * @beaninfo
  682.      *       expert: true
  683.      *  description: The AccessibleContext associated with this Label.
  684.      */
  685.     public AccessibleContext getAccessibleContext() {
  686.         if (accessibleContext == null) {
  687.             accessibleContext = new AccessibleJLabel();
  688.         }
  689.         return accessibleContext;
  690.     }
  691.  
  692.     /**
  693.      * The class used to obtain the accessible role for this object.
  694.      * <p>
  695.      * Warning: serialized objects of this class will not be compatible with
  696.      * future swing releases.  The current serialization support is appropriate
  697.      * for short term storage or RMI between Swing1.0 applications.  It will
  698.      * not be possible to load serialized Swing1.0 objects with future releases
  699.      * of Swing.  The JDK1.2 release of Swing will be the compatibility
  700.      * baseline for the serialized form of Swing objects.
  701.      */
  702.     protected class AccessibleJLabel extends AccessibleJComponent {
  703.  
  704.         /**
  705.          * Get the accessible name of this object.  
  706.          * 
  707.          * @return the localized name of the object -- can be null if this 
  708.          * object does not have a name
  709.          * @see AccessibleContext#setAccessibleName
  710.          */
  711.         public String getAccessibleName() {
  712.             if (accessibleName != null) {
  713.                 return accessibleName;
  714.             } else {
  715.                 if (getText() == null) {
  716.                     return super.getAccessibleName();
  717.                 } else {
  718.                     return getText();
  719.                 }
  720.             }
  721.         }
  722.  
  723.         /**
  724.          * Get the role of this object.
  725.          *
  726.          * @return an instance of AccessibleRole describing the role of the 
  727.          * object
  728.          * @see AccessibleRole
  729.          */
  730.         public AccessibleRole getAccessibleRole() {
  731.             return AccessibleRole.LABEL;
  732.         }
  733.  
  734.     }  // AccessibleJComponent
  735.  
  736.     /**
  737.      * Get the component this is labelling.
  738.      *
  739.      * @return the Component this is labelling.  Can be null if this
  740.      * does not label a Component.  If the displayedMnemonic 
  741.      * property is set and the labelFor property is also set, the label 
  742.      * will call the requestFocus method of the component specified by the
  743.      * labelFor property when the mnemonic is activated.
  744.      *
  745.      * @see #getDisplayedMnemonic
  746.      * @see #setDisplayedMnemonic
  747.      */
  748.     public Component getLabelFor() {
  749.         return labelFor;
  750.     }
  751.  
  752.     /**
  753.      * Set the component this is labelling.  Can be null if this does not 
  754.      * label a Component.  If the displayedMnemonic property is set
  755.      * and the labelFor property is also set, the label will
  756.      * call the requestFocus method of the component specified by the
  757.      * labelFor property when the mnemonic is activated.
  758.      *
  759.      * @param c  the Component this label is for, or null if the label is
  760.      *           not the label for a component
  761.      *
  762.      * @see #getDisplayedMnemonic
  763.      * @see #setDisplayedMnemonic
  764.      * @beaninfo
  765.      *        bound: true
  766.      *  description: The component this is labelling.
  767.      */
  768.     public void setLabelFor(Component c) {
  769.         Component oldC = labelFor;
  770.         labelFor = c;
  771.         firePropertyChange("labelFor", oldC, c);        
  772.     }
  773.  
  774. }
  775.  
  776.  
  777.